import { getTTSTaskStatus, TTSTaskStatus, type TTSTaskInfo } from '@/api/ai/tts'
import { ttsStorage } from './tts-storage'

/**
 * TTS 任务管理器 - 全局轮询未完成的任务
 */
export class TTSTaskManager {
  private static instance: TTSTaskManager | null = null
  private pollingTimer: number | null = null
  private isPolling = false
  private readonly POLLING_INTERVAL = 5000 // 5秒轮询一次（减少请求频率）
  private lastCheckTime = 0 // 上次检查时间
  private checkingTaskIds = new Set<number>() // 正在检查的任务ID集合

  // 事件监听器
  private listeners: {
    taskUpdate: ((taskInfo: TTSTaskInfo) => void)[]
    taskComplete: ((taskInfo: TTSTaskInfo) => void)[]
    taskFailed: ((taskInfo: TTSTaskInfo) => void)[]
  } = {
    taskUpdate: [],
    taskComplete: [],
    taskFailed: []
  }

  private constructor() {}

  /**
   * 获取单例实例
   */
  static getInstance(): TTSTaskManager {
    if (!TTSTaskManager.instance) {
      TTSTaskManager.instance = new TTSTaskManager()
    }
    return TTSTaskManager.instance
  }

  /**
   * 添加事件监听器
   */
  on(event: 'taskUpdate' | 'taskComplete' | 'taskFailed', callback: (taskInfo: TTSTaskInfo) => void): void {
    if (this.listeners[event]) {
      this.listeners[event].push(callback)
    }
  }

  /**
   * 移除事件监听器
   */
  off(event: 'taskUpdate' | 'taskComplete' | 'taskFailed', callback: (taskInfo: TTSTaskInfo) => void): void {
    if (this.listeners[event]) {
      const index = this.listeners[event].indexOf(callback)
      if (index > -1) {
        this.listeners[event].splice(index, 1)
      }
    }
  }

  /**
   * 触发事件
   */
  private emit(event: 'taskUpdate' | 'taskComplete' | 'taskFailed', taskInfo: TTSTaskInfo): void {
    if (this.listeners[event]) {
      this.listeners[event].forEach(callback => callback(taskInfo))
    }
  }

  /**
   * 开始全局轮询
   */
  async startGlobalPolling(): Promise<void> {
    if (this.isPolling) {
      return
    }

    console.log('TTS任务管理器：开始全局轮询')
    this.isPolling = true
    this.pollIncompleteTasks()
  }

  /**
   * 停止全局轮询
   */
  stopGlobalPolling(): void {
    if (this.pollingTimer) {
      clearTimeout(this.pollingTimer)
      this.pollingTimer = null
    }
    this.isPolling = false
    console.log('TTS任务管理器：停止全局轮询')
  }

  /**
   * 轮询未完成的任务
   */
  private async pollIncompleteTasks(): Promise<void> {
    if (!this.isPolling) {
      return
    }

    // 防止重复执行
    const now = Date.now()
    if (now - this.lastCheckTime < 2000) {
      this.scheduleNextPoll()
      return
    }
    this.lastCheckTime = now

    try {
      // 获取所有未完成的任务
      const incompleteTasks = await ttsStorage.getIncompleteTasks()

      if (incompleteTasks.length === 0) {
        // 没有未完成的任务，继续轮询但间隔可以长一些
        this.scheduleNextPoll(10000) // 无任务时10秒检查一次
        return
      }

      // 过滤掉正在检查的任务
      const tasksToCheck = incompleteTasks.filter(task => !this.checkingTaskIds.has(task.id))
      
      if (tasksToCheck.length === 0) {
        this.scheduleNextPoll()
        return
      }

      console.log(`TTS任务管理器：检查 ${tasksToCheck.length} 个未完成任务`)

      // 标记正在检查的任务
      tasksToCheck.forEach(task => this.checkingTaskIds.add(task.id))

      // 并发检查所有未完成任务的状态（限制并发数）
      const batchSize = 5 // 每批最多5个
      const batches = []
      for (let i = 0; i < tasksToCheck.length; i += batchSize) {
        batches.push(tasksToCheck.slice(i, i + batchSize))
      }

      for (const batch of batches) {
        const updatePromises = batch.map(task => this.checkTaskStatus(task))
        const updatedTasks = await Promise.allSettled(updatePromises)

        // 收集成功更新的任务
        const tasksToUpdate: TTSTaskInfo[] = []

        updatedTasks.forEach((result, index) => {
          const task = batch[index]
          // 移除检查标记
          this.checkingTaskIds.delete(task.id)
          
          if (result.status === 'fulfilled' && result.value) {
            const updatedTask = result.value

            // 触发相应的事件
            this.emit('taskUpdate', updatedTask)

            if (updatedTask.status === TTSTaskStatus.COMPLETED) {
              this.emit('taskComplete', updatedTask)
            } else if (updatedTask.status === TTSTaskStatus.FAILED) {
              this.emit('taskFailed', updatedTask)
            }

            // 只有状态发生变化时才需要更新
            if (task.status !== updatedTask.status || 
                task.fileUrl !== updatedTask.fileUrl ||
                task.statusDesc !== updatedTask.statusDesc) {
              tasksToUpdate.push(updatedTask)
            }
          }
        })

        // 批量更新数据库
        if (tasksToUpdate.length > 0) {
          await ttsStorage.updateTasksStatus(tasksToUpdate)
        }
      }

    } catch (error) {
      console.error('TTS任务管理器：轮询过程中发生错误:', error)
    }

    // 安排下一次轮询
    this.scheduleNextPoll()
  }

  /**
   * 检查单个任务状态
   */
  private async checkTaskStatus(task: TTSTaskInfo): Promise<TTSTaskInfo | null> {
    try {
      const response = await getTTSTaskStatus(task.id)

      return response.data

    } catch (error) {
      console.error(`检查任务 ${task.id} 状态时发生错误:`, error)
      return null
    }
  }

  /**
   * 安排下一次轮询
   */
  private scheduleNextPoll(interval?: number): void {
    if (this.isPolling) {
      // 清除旧的定时器
      if (this.pollingTimer) {
        clearTimeout(this.pollingTimer)
      }
      
      this.pollingTimer = window.setTimeout(() => {
        this.pollIncompleteTasks()
      }, interval || this.POLLING_INTERVAL)
    }
  }

  /**
   * 获取轮询状态
   */
  isRunning(): boolean {
    return this.isPolling
  }

  /**
   * 手动触发一次轮询检查
   */
  async triggerCheck(): Promise<void> {
    if (!this.isPolling) {
      await this.startGlobalPolling()
    } else {
      // 重置检查时间，允许立即执行
      this.lastCheckTime = 0
      // 立即执行一次检查
      this.pollIncompleteTasks()
    }
  }
}

// 导出单例实例
export const ttsTaskManager = TTSTaskManager.getInstance()

// 页面加载时自动开始轮询
if (typeof window !== 'undefined') {
  // 确保在浏览器环境中执行
  document.addEventListener('DOMContentLoaded', () => {
    ttsTaskManager.startGlobalPolling()
  })

  // 页面关闭时停止轮询
  window.addEventListener('beforeunload', () => {
    ttsTaskManager.stopGlobalPolling()
  })

  // 页面隐藏时停止轮询，显示时重新开始
  document.addEventListener('visibilitychange', () => {
    if (document.hidden) {
      ttsTaskManager.stopGlobalPolling()
    } else {
      ttsTaskManager.startGlobalPolling()
    }
  })
}
